上一篇的解答：

infix fun <T, Q, R> ((T) -> Q).pipe(anotherFun: (Q) -> R): (T) -> R {
    return { x: T ->
        anotherFun(this(x))
    }
}

接下來要介紹另外兩個重要的概念了： Pure function 跟 Immutability，其實不只在 function programming ，在 Object oriented programming 中，如果好好掌握好 Pure function 與 Immutability 這兩個概念的話，會讓你寫的程式更好維護，也會產生更少的 bug。

Pure function

怎樣 function 才能算是“純”的呢？要多純？這樣說好了，任何我們以前在學校學的數學函式都是 Pure function。Pure function 就是，給定一個輸入，會有唯一一個輸出的結果，不會因為任何因素（時空/星座/長相）影響到結果，如下方所示：

f(x) = x * 3

如果輸入是 1 ，那輸出永遠都會是 3 ，如果是入是3，那輸出會是9，不可能會是 6 或是其他的值。看到這邊你可能會覺得：蛤？當然每個 function 都一定會是 pure funciton 啊，怎麼可能會有其他的可能性？沒錯，以數學式來說的話，的確很難不是 pure function 。很可惜的是，我們在寫程式，卻通常不是這麼一回事，隨時隨地都在寫不 pure 的 function。

fun Int.dpToPx(): Int {
    val density = Resources.getSystem().displayMetrics.density
    return Math.round(this * density)
}

看看上面這個例子，他是一個 extension function，這個 function 主要的目的是要做單位換算，大家可以不用知道這些單位是什麼意思（但Android 工程師不能不知道），只要知道這個 function 主要計算的公式只有 this*density 就好，頂多再加上 Math.round，一切都看似很單純。然而實際上，當 Android application 在執行時，這個值也永遠會是固定的，所以...這是一個 pure function 了嗎？

答案當然是 - 他不是一個 pure function。當你換不同手機來執行的時候，這個值就會不一樣了，為什麼呢？因為這個 function 相依了一個 global Singleton - Resources.getSystem() ，這邊的值會因為環境不同而有所改變，下面再列幾個例子：

// Pure functions
fun divide(a: Int, b: Int) = a / b       
// 遞迴也可以是 Pure function
fun triangleArea(height: Int): Int {
    return if (height == 1) {
        1
    } else {
        height + triangleArea(height - 1)
    }
}

// Non-Pure functions
// globalVariable 可能會被其他人改變
var globalVariable = 4
fun interactWithGlobal(a: Int) = a + globalVariable
// 也是一個常見的 case，Singleton 不在這個 function 的控制範圍
fun insertData(data: User): Boolean {
    return UserRepository.getInstance().insert(data)
}

// Pure function
// 雖然不在 function 的控制範圍，但是由於是常數，所以輸入跟輸出是恆定的 
const val constVariable = 5
fun interactWithConst(a: Int) = a + constVariable        

Referential transparency

在講到 Function programming 時常常會提到這概念，但不知道為什麼，一開始在學的時候卻怎麼都搞不懂。還有人說他只是 pure function 比較 fancy 的說法？這讓我更混亂了。但後來看了更多之後發現其實這是個很簡單的概念，讓我們先專注在他的“數學含義“。

每個人都背過99乘法表對吧？我們為什麼要去背他呢？因為這是一個很常見的計算，我們並不想要在做乘法的時候還要一個一個的用加法從頭計算，這實在是太浪費時間了。事實上，在這過程中，我們已經運用了 Referential transparency 的概念：

// 從以前學的數學中，我們知道下面這件事
5+5+5+5+5 = 5 * 5 = 25
// 在計算較複雜的算式時，可以利用已知的等式，來做“替換”
a = 5 + 5 + 5 + 5 + 5
b = 3 + 3 + 3 + 3
a + b = 5*5 + 3*4      // 將加法替換成乘法
      = 25 + 12        // 對照 99 乘法表，可以直接換到實際數值
      = 37

如果用更抽象一點的語言來說的話，如果我現在知道 a 可以推導到 b 這個結果，而 b 可以推導到 c的結果，自然而然的就可以從 a 推導到 c 。這件事對於“人腦”而言是非常自然的，這就是基本的邏輯推導。

讓我們來看看反例，很多人是在寫 javascript 的時候才第一次接觸到 functional programming ，但你知道嗎，這個程式語言的設計，處處與 functional programming 的原則起衝突！看看下面這張圖：

如果是符合 referential transparency 的話 ，"0" == [] 應該要回傳 true 才對！

Immutability

Mutable 跟 immutable 對於很多人來說不是一個新概念，在很多物件導向的書籍也有提到，但由於他在 functional programming 裡也是一個非常重要的觀念，在這邊針對他對 functional programming 的意義來做解說。

TL;DR - mutable 就是可變的變數，immutable 則是不可變的變數

class Point(var x: Int, var y: Int)

fun foo(point: Point): Int {
    return point.x + 4
}

fun boo(point: Point): Int {
    point.x = 100
    return distance (point, Point(0, 0))
}

上方的範例中 boo 這個 function 改變了 point 的其中一個值，如果 foo 跟 boo 背後所用的 point 是同一個的話，這兩個 function 的執行順序將會大大的影響結果！同時，也自然不會是 pure function，以下提供 immutable 的版本：

//1
data class Point(val x: Int, val y: Int)
fun foo(point: Point): Int { 
    return point.x + 4
}
fun boo(point: Point): Int { 
    //2
    val newPoint = point.copy(x = 100)
    return distance (point, Point(0, 0))
}

1. 將物件的所有變數都指定為 val ，如此一來，可以防止有人不小心修改到裡面的值。
2. data class 內建 copy 這個 function ，這個 function 的功能是複製，同時可以指定要改哪一個變數，並回傳一個新的實例（immutable）。如此一來就不會使用或改到原來的變數了。

Functional programming 在實務上其中一個最大的應用場景是：平行化運算。在平行運算中如果使用了共享的可變變數，是會發生很多災難的。

練習

請各位看看下面這個例子：

class Account(val id: Int, val money: Money)

val accountA = Account(...)

請問 accountA 這個變數是 immutable 嗎？，如果不是，為什麼呢？答案將在下回分曉